From 88d4546a36fd9f6d3117a97dc6c1d06629dc2b78 Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Sun, 29 Apr 2007 03:31:03 +0000 Subject: [PATCH] Correct some copyright lines. 2007-04-28 Matthias Clasen * modules/printbackends/lpr/*: * modules/printbackends/cups/*: Correct some copyright lines. * configure.in: * modules/printbackends/Makefile.am: * modules/printbackends/test/*: Add a test print backend. (#409089, John Palmieri) svn path=/trunk/; revision=17686 --- ChangeLog | 10 + configure.in | 19 + modules/printbackends/Makefile.am | 4 +- modules/printbackends/cups/gtkcupsutils.c | 2 +- .../printbackends/cups/gtkprintbackendcups.h | 2 +- .../printbackends/lpr/gtkprintbackendlpr.c | 4 +- .../printbackends/lpr/gtkprintbackendlpr.h | 4 +- modules/printbackends/test/Makefile.am | 33 + .../printbackends/test/gtkprintbackendtest.c | 598 ++++++++++++++++++ .../printbackends/test/gtkprintbackendtest.h | 41 ++ 10 files changed, 709 insertions(+), 8 deletions(-) create mode 100644 modules/printbackends/test/Makefile.am create mode 100644 modules/printbackends/test/gtkprintbackendtest.c create mode 100644 modules/printbackends/test/gtkprintbackendtest.h diff --git a/ChangeLog b/ChangeLog index 49cab2d9aa..4d7f057b21 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,13 @@ +2007-04-28 Matthias Clasen + + * modules/printbackends/lpr/*: + * modules/printbackends/cups/*: Correct some copyright lines. + + * configure.in: + * modules/printbackends/Makefile.am: + * modules/printbackends/test/*: Add a test print backend. + (#409089, John Palmieri) + 2007-04-28 Matthias Clasen * gtk/gtktexttag.[hc]: Add a way to specify accumulative diff --git a/configure.in b/configure.in index 128c1f49b9..09b550765d 100644 --- a/configure.in +++ b/configure.in @@ -1295,6 +1295,24 @@ if test "x$gdktarget" = "xx11"; then GTK_PACKAGES_FOR_X="$GTK_PACKAGES_FOR_X xfixes" fi + # Checks for Xcomposite extension + + if $PKG_CONFIG --exists xcomposite ; then + AC_DEFINE(HAVE_XCOMPOSITE, 1, Have the XCOMPOSITE X extension) + + X_PACKAGES="$X_PACKAGES xcomposite" + GTK_PACKAGES_FOR_X="$GTK_PACKAGES_FOR_X xcomposite" + fi + + # Checks for Xdamage extension + + if $PKG_CONFIG --exists xdamage ; then + AC_DEFINE(HAVE_XDAMAGE, 1, Have the XDAMAGE X extension) + + X_PACKAGES="$X_PACKAGES xdamage" + GTK_PACKAGES_FOR_X="$GTK_PACKAGES_FOR_X xdamage" + fi + if $have_base_x_pc ; then GDK_EXTRA_LIBS="$x_extra_libs" else @@ -1724,6 +1742,7 @@ modules/printbackends/Makefile modules/printbackends/cups/Makefile modules/printbackends/lpr/Makefile modules/printbackends/file/Makefile +modules/printbackends/test/Makefile perf/Makefile contrib/Makefile contrib/gdk-pixbuf-xlib/Makefile diff --git a/modules/printbackends/Makefile.am b/modules/printbackends/Makefile.am index 48d3fa26ba..58c03da851 100644 --- a/modules/printbackends/Makefile.am +++ b/modules/printbackends/Makefile.am @@ -1,7 +1,7 @@ -SUBDIRS = file lpr +SUBDIRS = file lpr test if HAVE_CUPS SUBDIRS += cups endif -DIST_SUBDIRS=cups file lpr +DIST_SUBDIRS=cups file lpr test diff --git a/modules/printbackends/cups/gtkcupsutils.c b/modules/printbackends/cups/gtkcupsutils.c index e11c865296..d5a6bab012 100644 --- a/modules/printbackends/cups/gtkcupsutils.c +++ b/modules/printbackends/cups/gtkcupsutils.c @@ -1,6 +1,6 @@ /* GTK - The GIMP Toolkit * gtkcupsutils.h: Statemachine implementation of POST and GET - * cup calls which can be used to create a non-blocking cups API + * cups calls which can be used to create a non-blocking cups API * Copyright (C) 2006, 2007 Red Hat, Inc. * * This library is free software; you can redistribute it and/or diff --git a/modules/printbackends/cups/gtkprintbackendcups.h b/modules/printbackends/cups/gtkprintbackendcups.h index b1e136970a..81c1d987aa 100644 --- a/modules/printbackends/cups/gtkprintbackendcups.h +++ b/modules/printbackends/cups/gtkprintbackendcups.h @@ -1,6 +1,6 @@ /* GTK - The GIMP Toolkit * gtkprintbackendcups.h: Default implementation of GtkPrintBackend for the Common Unix Print System (CUPS) - * Copyright (C) 2003, Red Hat, Inc. + * Copyright (C) 2006, 2007 Red Hat, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public diff --git a/modules/printbackends/lpr/gtkprintbackendlpr.c b/modules/printbackends/lpr/gtkprintbackendlpr.c index f8a7a06101..8febe7c71c 100644 --- a/modules/printbackends/lpr/gtkprintbackendlpr.c +++ b/modules/printbackends/lpr/gtkprintbackendlpr.c @@ -1,7 +1,7 @@ /* GTK - The GIMP Toolkit - * gtkprintbackendlpr.c: Default implementation of GtkPrintBackend + * gtkprintbackendlpr.c: LPR implementation of GtkPrintBackend * for printing to lpr - * Copyright (C) 2003, Red Hat, Inc. + * Copyright (C) 2006, 2007 Red Hat, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public diff --git a/modules/printbackends/lpr/gtkprintbackendlpr.h b/modules/printbackends/lpr/gtkprintbackendlpr.h index 7a7f79a6fa..51c529a2fa 100644 --- a/modules/printbackends/lpr/gtkprintbackendlpr.h +++ b/modules/printbackends/lpr/gtkprintbackendlpr.h @@ -1,7 +1,7 @@ /* GTK - The GIMP Toolkit - * gtkprintbackendlpr.h: Default implementation of GtkPrintBackend + * gtkprintbackendlpr.h: LPR implementation of GtkPrintBackend * for printing to lpr - * Copyright (C) 2003, Red Hat, Inc. + * Copyright (C) 2006, 2007 Red Hat, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public diff --git a/modules/printbackends/test/Makefile.am b/modules/printbackends/test/Makefile.am new file mode 100644 index 0000000000..cbbfd60348 --- /dev/null +++ b/modules/printbackends/test/Makefile.am @@ -0,0 +1,33 @@ +if OS_WIN32 +no_undefined = -no-undefined +endif + +backenddir = $(libdir)/gtk-2.0/$(GTK_BINARY_VERSION)/printbackends + +backend_LTLIBRARIES = libprintbackend-test.la + +libprintbackend_test_la_SOURCES = \ + gtkprintbackendtest.c + +libprintbackend_test_la_CPPFLAGS = \ + -I$(top_srcdir) \ + -I$(top_srcdir)/gtk \ + -I$(top_builddir)/gtk \ + -I$(top_srcdir)/gdk \ + -I$(top_builddir)/gdk \ + -DGTK_PRINT_BACKEND_ENABLE_UNSUPPORTED \ + $(AM_CPPFLAGS) + +libprintbackend_test_la_CFLAGS = \ + $(GTK_DEP_CFLAGS) \ + $(AM_CFLAGS) + +libprintbackend_test_la_LDFLAGS = \ + -avoid-version -module $(no_undefined) + +libprintbackend_test_la_LIBADD = \ + $(top_builddir)/gtk/$(gtktargetlib) \ + $(GTK_DEP_LIBS) + +noinst_HEADERS = \ + gtkprintbackendtest.h diff --git a/modules/printbackends/test/gtkprintbackendtest.c b/modules/printbackends/test/gtkprintbackendtest.c new file mode 100644 index 0000000000..1b9aa8014e --- /dev/null +++ b/modules/printbackends/test/gtkprintbackendtest.c @@ -0,0 +1,598 @@ +/* GTK - The GIMP Toolkit + * gtkprintbackendpdf.c: Test implementation of GtkPrintBackend + * for printing to a test + * Copyright (C) 2007, Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include "gtkprintoperation.h" + +#include "gtkprintbackend.h" +#include "gtkprintbackendtest.h" + +#include "gtkprinter.h" +#include "gtkprinter-private.h" + +typedef struct _GtkPrintBackendTestClass GtkPrintBackendTestClass; + +#define GTK_PRINT_BACKEND_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_BACKEND_TEST, GtkPrintBackendTestClass)) +#define GTK_IS_PRINT_BACKEND_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_BACKEND_TEST)) +#define GTK_PRINT_BACKENDTEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_BACKEND_TEST, GtkPrintBackendTestClass)) + +#define _STREAM_MAX_CHUNK_SIZE 8192 + +static GType print_backend_test_type = 0; + +struct _GtkPrintBackendTestClass +{ + GtkPrintBackendClass parent_class; +}; + +struct _GtkPrintBackendTest +{ + GtkPrintBackend parent_instance; +}; + +typedef enum +{ + FORMAT_PDF, + FORMAT_PS, + N_FORMATS +} OutputFormat; + +static const gchar* formats[N_FORMATS] = +{ + "pdf", + "ps" +}; + +static GObjectClass *backend_parent_class; + +static void gtk_print_backend_test_class_init (GtkPrintBackendTestClass *class); +static void gtk_print_backend_test_init (GtkPrintBackendTest *impl); +static void test_printer_get_settings_from_options (GtkPrinter *printer, + GtkPrinterOptionSet *options, + GtkPrintSettings *settings); +static GtkPrinterOptionSet *test_printer_get_options (GtkPrinter *printer, + GtkPrintSettings *settings, + GtkPageSetup *page_setup, + GtkPrintCapabilities capabilities); +static void test_printer_prepare_for_print (GtkPrinter *printer, + GtkPrintJob *print_job, + GtkPrintSettings *settings, + GtkPageSetup *page_setup); +static void gtk_print_backend_test_print_stream (GtkPrintBackend *print_backend, + GtkPrintJob *job, + GIOChannel *data_io, + GtkPrintJobCompleteFunc callback, + gpointer user_data, + GDestroyNotify dnotify); +static cairo_surface_t * test_printer_create_cairo_surface (GtkPrinter *printer, + GtkPrintSettings *settings, + gdouble width, + gdouble height, + GIOChannel *cache_io); + +static void test_printer_request_details (GtkPrinter *printer); + +static void +gtk_print_backend_test_register_type (GTypeModule *module) +{ + static const GTypeInfo print_backend_test_info = + { + sizeof (GtkPrintBackendTestClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) gtk_print_backend_test_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GtkPrintBackendTest), + 0, /* n_preallocs */ + (GInstanceInitFunc) gtk_print_backend_test_init, + }; + + print_backend_test_type = g_type_module_register_type (module, + GTK_TYPE_PRINT_BACKEND, + "GtkPrintBackendTest", + &print_backend_test_info, 0); +} + +G_MODULE_EXPORT void +pb_module_init (GTypeModule *module) +{ + gtk_print_backend_test_register_type (module); +} + +G_MODULE_EXPORT void +pb_module_exit (void) +{ + +} + +G_MODULE_EXPORT GtkPrintBackend * +pb_module_create (void) +{ + return gtk_print_backend_test_new (); +} + +/* + * GtkPrintBackendTest + */ +GType +gtk_print_backend_test_get_type (void) +{ + return print_backend_test_type; +} + +/** + * gtk_print_backend_test_new: + * + * Creates a new #GtkPrintBackendTest object. #GtkPrintBackendTest + * implements the #GtkPrintBackend interface with direct access to + * the testsystem using Unix/Linux API calls + * + * Return value: the new #GtkPrintBackendTest object + **/ +GtkPrintBackend * +gtk_print_backend_test_new (void) +{ + return g_object_new (GTK_TYPE_PRINT_BACKEND_TEST, NULL); +} + +static void +gtk_print_backend_test_class_init (GtkPrintBackendTestClass *class) +{ + GtkPrintBackendClass *backend_class = GTK_PRINT_BACKEND_CLASS (class); + + backend_parent_class = g_type_class_peek_parent (class); + + backend_class->print_stream = gtk_print_backend_test_print_stream; + backend_class->printer_create_cairo_surface = test_printer_create_cairo_surface; + backend_class->printer_get_options = test_printer_get_options; + backend_class->printer_get_settings_from_options = test_printer_get_settings_from_options; + backend_class->printer_prepare_for_print = test_printer_prepare_for_print; + backend_class->printer_request_details = test_printer_request_details; +} + +/* return N_FORMATS if no explicit format in the settings */ +static OutputFormat +format_from_settings (GtkPrintSettings *settings) +{ + const gchar *value; + gint i; + + if (settings == NULL) + return N_FORMATS; + + value = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT); + if (value == NULL) + return N_FORMATS; + + for (i = 0; i < N_FORMATS; ++i) + if (strcmp (value, formats[i]) == 0) + break; + + g_assert (i < N_FORMATS); + + return (OutputFormat) i; +} + +static gchar * +output_test_from_settings (GtkPrintSettings *settings, + const gchar *default_format) +{ + gchar *uri = NULL; + + if (settings) + uri = g_strdup (gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_URI)); + + if (uri == NULL) + { + const gchar *extension; + gchar *name, *locale_name, *path; + + if (default_format) + extension = default_format; + else + { + OutputFormat format; + + format = format_from_settings (settings); + extension = format == FORMAT_PS ? "ps" : "pdf"; + } + + /* default filename used for print-to-test */ + name = g_strdup_printf (_("test-output.%s"), extension); + locale_name = g_filename_from_utf8 (name, -1, NULL, NULL, NULL); + g_free (name); + + if (locale_name != NULL) + { + path = g_build_filename (g_get_current_dir (), locale_name, NULL); + g_free (locale_name); + + uri = g_filename_to_uri (path, NULL, NULL); + g_free (path); + } + } + + return uri; +} + +static cairo_status_t +_cairo_write (void *closure, + const unsigned char *data, + unsigned int length) +{ + GIOChannel *io = (GIOChannel *)closure; + gsize written; + GError *error; + + error = NULL; + + GTK_NOTE (PRINTING, + g_print ("TEST Backend: Writing %i byte chunk to temp test\n", length)); + + while (length > 0) + { + g_io_channel_write_chars (io, (const gchar *) data, length, &written, &error); + + if (error != NULL) + { + GTK_NOTE (PRINTING, + g_print ("TEST Backend: Error writing to temp test, %s\n", error->message)); + + g_error_free (error); + return CAIRO_STATUS_WRITE_ERROR; + } + + GTK_NOTE (PRINTING, + g_print ("TEST Backend: Wrote %i bytes to temp test\n", (int)written)); + + data += written; + length -= written; + } + + return CAIRO_STATUS_SUCCESS; +} + + +static cairo_surface_t * +test_printer_create_cairo_surface (GtkPrinter *printer, + GtkPrintSettings *settings, + gdouble width, + gdouble height, + GIOChannel *cache_io) +{ + cairo_surface_t *surface; + OutputFormat format; + + format = format_from_settings (settings); + + if (format == FORMAT_PS) + surface = cairo_ps_surface_create_for_stream (_cairo_write, cache_io, width, height); + else + surface = cairo_pdf_surface_create_for_stream (_cairo_write, cache_io, width, height); + + /* TODO: DPI from settings object? */ + cairo_surface_set_fallback_resolution (surface, 300, 300); + + return surface; +} + +typedef struct { + GtkPrintBackend *backend; + GtkPrintJobCompleteFunc callback; + GtkPrintJob *job; + GIOChannel *target_io; + gpointer user_data; + GDestroyNotify dnotify; +} _PrintStreamData; + +static void +test_print_cb (GtkPrintBackendTest *print_backend, + GError *error, + gpointer user_data) +{ + _PrintStreamData *ps = (_PrintStreamData *) user_data; + + if (ps->target_io != NULL) + g_io_channel_unref (ps->target_io); + + if (ps->callback) + ps->callback (ps->job, ps->user_data, error); + + if (ps->dnotify) + ps->dnotify (ps->user_data); + + gtk_print_job_set_status (ps->job, + (error != NULL)?GTK_PRINT_STATUS_FINISHED_ABORTED:GTK_PRINT_STATUS_FINISHED); + + if (ps->job) + g_object_unref (ps->job); + + g_free (ps); +} + +static gboolean +test_write (GIOChannel *source, + GIOCondition con, + gpointer user_data) +{ + gchar buf[_STREAM_MAX_CHUNK_SIZE]; + gsize bytes_read; + GError *error; + GIOStatus read_status; + _PrintStreamData *ps = (_PrintStreamData *) user_data; + + error = NULL; + + read_status = + g_io_channel_read_chars (source, + buf, + _STREAM_MAX_CHUNK_SIZE, + &bytes_read, + &error); + + if (read_status != G_IO_STATUS_ERROR) + { + gsize bytes_written; + + g_io_channel_write_chars (ps->target_io, + buf, + bytes_read, + &bytes_written, + &error); + } + + if (error != NULL || read_status == G_IO_STATUS_EOF) + { + test_print_cb (GTK_PRINT_BACKEND_TEST (ps->backend), error, user_data); + + if (error != NULL) + { + GTK_NOTE (PRINTING, + g_print ("TEST Backend: %s\n", error->message)); + + g_error_free (error); + } + + return FALSE; + } + + GTK_NOTE (PRINTING, + g_print ("TEST Backend: Writing %i byte chunk to target test\n", (int)bytes_read)); + + return TRUE; +} + +static void +gtk_print_backend_test_print_stream (GtkPrintBackend *print_backend, + GtkPrintJob *job, + GIOChannel *data_io, + GtkPrintJobCompleteFunc callback, + gpointer user_data, + GDestroyNotify dnotify) +{ + GError *internal_error = NULL; + GtkPrinter *printer; + _PrintStreamData *ps; + GtkPrintSettings *settings; + gchar *uri, *testname; + + printer = gtk_print_job_get_printer (job); + settings = gtk_print_job_get_settings (job); + + ps = g_new0 (_PrintStreamData, 1); + ps->callback = callback; + ps->user_data = user_data; + ps->dnotify = dnotify; + ps->job = g_object_ref (job); + ps->backend = print_backend; + + internal_error = NULL; + uri = output_test_from_settings (settings, NULL); + testname = g_filename_from_uri (uri, NULL, &internal_error); + g_free (uri); + + if (testname == NULL) + goto error; + + ps->target_io = g_io_channel_new_file (testname, "w", &internal_error); + + g_free (testname); + + if (internal_error == NULL) + g_io_channel_set_encoding (ps->target_io, NULL, &internal_error); + +error: + if (internal_error != NULL) + { + test_print_cb (GTK_PRINT_BACKEND_TEST (print_backend), + internal_error, ps); + + g_error_free (internal_error); + return; + } + + g_io_add_watch (data_io, + G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, + (GIOFunc) test_write, + ps); +} + +static void +gtk_print_backend_test_init (GtkPrintBackendTest *backend) +{ + GtkPrinter *printer; + int i; + + /* make 100 of these printers */ + for (i=0; i<100; i++) + { + char *name; + name = g_strdup_printf ("%s %i", _("Print to Test Printer"), i); + printer = g_object_new (GTK_TYPE_PRINTER, + "name", name, + "backend", backend, + "is-virtual", FALSE, /* treat printer like a real one*/ + NULL); + g_free(name); + + gtk_printer_set_has_details (printer, FALSE); + gtk_printer_set_icon_name (printer, "gtk-delete"); /* use a delete icon just for fun */ + gtk_printer_set_is_active (printer, TRUE); + + gtk_print_backend_add_printer (GTK_PRINT_BACKEND (backend), printer); + g_object_unref (printer); + } + + gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (backend)); +} + +static GtkPrinterOptionSet * +test_printer_get_options (GtkPrinter *printer, + GtkPrintSettings *settings, + GtkPageSetup *page_setup, + GtkPrintCapabilities capabilities) +{ + GtkPrinterOptionSet *set; + GtkPrinterOption *option; + const gchar *n_up[] = { "1" }; + const gchar *format_names[N_FORMATS] = { N_("PDF"), N_("Postscript") }; + const gchar *supported_formats[N_FORMATS]; + gchar *display_format_names[N_FORMATS]; + gint n_formats = 0; + OutputFormat format; + gchar *uri; + gint current_format = 0; + + format = format_from_settings (settings); + + set = gtk_printer_option_set_new (); + + option = gtk_printer_option_new ("gtk-n-up", _("Pages per _sheet:"), GTK_PRINTER_OPTION_TYPE_PICKONE); + gtk_printer_option_choices_from_array (option, G_N_ELEMENTS (n_up), + (char **) n_up, (char **) n_up /* FIXME i18n (localised digits)! */); + gtk_printer_option_set (option, "1"); + gtk_printer_option_set_add (set, option); + g_object_unref (option); + + return set; +} + +static void +test_printer_get_settings_from_options (GtkPrinter *printer, + GtkPrinterOptionSet *options, + GtkPrintSettings *settings) +{ +} + +static void +test_printer_prepare_for_print (GtkPrinter *printer, + GtkPrintJob *print_job, + GtkPrintSettings *settings, + GtkPageSetup *page_setup) +{ + gdouble scale; + + print_job->print_pages = gtk_print_settings_get_print_pages (settings); + print_job->page_ranges = NULL; + print_job->num_page_ranges = 0; + + if (print_job->print_pages == GTK_PRINT_PAGES_RANGES) + print_job->page_ranges = + gtk_print_settings_get_page_ranges (settings, + &print_job->num_page_ranges); + + print_job->collate = gtk_print_settings_get_collate (settings); + print_job->reverse = gtk_print_settings_get_reverse (settings); + print_job->num_copies = gtk_print_settings_get_n_copies (settings); + + scale = gtk_print_settings_get_scale (settings); + if (scale != 100.0) + print_job->scale = scale/100.0; + + print_job->page_set = gtk_print_settings_get_page_set (settings); + print_job->rotate_to_orientation = TRUE; +} + +static gboolean +test_printer_details_aquired_cb (GtkPrinter *printer) +{ + gboolean success; + gint weight; + + /* weight twords success */ + weight = g_random_int_range(0, 100); + + success = FALSE; + if (weight < 75) + success = TRUE; + + g_message ("success %i", success); + gtk_printer_set_has_details (printer, success); + g_signal_emit_by_name (printer, "details-acquired", success); + + return FALSE; +} + +static void +test_printer_request_details (GtkPrinter *printer) +{ + gint weight; + gint time; + /* set the timer to succeed or fail at a random time interval */ + /* weight twords the shorter end */ + weight = g_random_int_range(0, 100); + if (weight < 50) + time = g_random_int_range(0, 2); + else if (weight < 75) + time = g_random_int_range(1, 5); + else + time = g_random_int_range(1, 10); + + g_message ("Gathering details in %i seconds", time); + + if (time == 0) + time = 10; + else + time *= 1000; + + g_timeout_add(time, + (GSourceFunc) test_printer_details_aquired_cb, + printer + ); +} + + diff --git a/modules/printbackends/test/gtkprintbackendtest.h b/modules/printbackends/test/gtkprintbackendtest.h new file mode 100644 index 0000000000..c48a85a198 --- /dev/null +++ b/modules/printbackends/test/gtkprintbackendtest.h @@ -0,0 +1,41 @@ +/* GTK - The GIMP Toolkit + * gtkprintbackendtest.h: Test implementation of GtkPrintBackend + * for testing the dialog + * Copyright (C) 2007, Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GTK_PRINT_BACKEND_TEST_H__ +#define __GTK_PRINT_BACKEND_TEST_H__ + +#include +#include "gtkprintbackend.h" + +G_BEGIN_DECLS + +#define GTK_TYPE_PRINT_BACKEND_TEST (gtk_print_backend_test_get_type ()) +#define GTK_PRINT_BACKEND_TEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_BACKEND_TEST, GtkPrintBackendTest)) +#define GTK_IS_PRINT_BACKEND_TEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_BACKEND_TEST)) + +typedef struct _GtkPrintBackendTest GtkPrintBackendTest; + +GtkPrintBackend *gtk_print_backend_test_new (void); +GType gtk_print_backend_test_get_type (void) G_GNUC_CONST; + +G_END_DECLS + +#endif /* __GTK_PRINT_BACKEND_TEST_H__ */ -- 2.30.2